package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade CERTIFICADO_CALIBRACAO
 * @author Gerado pelo Telescope
 */
public class EntCertificadoCalibracao extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.CERTIFICADO_CALIBRACAO";
    public final static String TABLE_NAME = "CERTIFICADO_CALIBRACAO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntCertificadoCalibracao() {
        super();
        initialize();
    }
    
    public EntCertificadoCalibracao(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aInstrumentoEnsaioId = new DomId(this,"INSTRUMENTO_ENSAIO_ID", "Instrumento de ensaio"); 
        aInstrumentoEnsaioId.setRequired(true);
        oInstrumentoEnsaioId = new DomId();
        aDataCalibracao = new DomDate(this,"DATA_CALIBRACAO", "Data da calibração"); 
        aDataCalibracao.setRequired(true);
        oDataCalibracao = new DomDate();
        aDataValidade = new DomDate(this,"DATA_VALIDADE", "Data de validade da calibração"); 
        aDataValidade.setRequired(true);
        oDataValidade = new DomDate();
        aCertificado = new DomText(this,"CERTIFICADO", "Certificado da calibração"); 
        aCertificado.setRequired(true);
        aCertificado.setSize(25);
        oCertificado = new DomText();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Instrumento de ensaio
    private DomId aInstrumentoEnsaioId;
    private DomId oInstrumentoEnsaioId;
    
    // Data da calibração
    private DomDate aDataCalibracao;
    private DomDate oDataCalibracao;
    
    // Data de validade da calibração
    private DomDate aDataValidade;
    private DomDate oDataValidade;
    
    // Certificado da calibração
    private DomText aCertificado;
    private DomText oCertificado;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntCertificadoCalibracao id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INSTRUMENTO_ENSAIO_ID">
    
    public EntCertificadoCalibracao instrumentoEnsaioId(Long value) {
        setInstrumentoEnsaioId(value);
        return this;
    }
    
    public void setInstrumentoEnsaioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyInstrumentoEnsaioId();
        } else {
            aInstrumentoEnsaioId.setValue(value.getValue());
            if (aInstrumentoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInstrumentoEnsaioId(String value) {
        if (value == null) {
            nullifyInstrumentoEnsaioId();
        } else {
            aInstrumentoEnsaioId.setValue(value);
            if (aInstrumentoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInstrumentoEnsaioId(Long value) {
        aInstrumentoEnsaioId.setValue(value);
        if (aInstrumentoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setInstrumentoEnsaioId(Object value) {
        aInstrumentoEnsaioId.setValue(value);
        if (aInstrumentoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyInstrumentoEnsaioId() {
        if (!aInstrumentoEnsaioId.isNull()) {
            aInstrumentoEnsaioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getInstrumentoEnsaioId() {
        return aInstrumentoEnsaioId;
    }
    
    public DomId oldInstrumentoEnsaioId() {
        return oInstrumentoEnsaioId;
    }
    
    public Long valueOfInstrumentoEnsaioId() {
        return aInstrumentoEnsaioId.getValue();
    }
    
    public boolean isInstrumentoEnsaioIdModified() {
        return aInstrumentoEnsaioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_CALIBRACAO">
    
    public EntCertificadoCalibracao dataCalibracao(java.sql.Date value) {
        setDataCalibracao(value);
        return this;
    }
    
    public void setDataCalibracao(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataCalibracao();
        } else {
            aDataCalibracao.setValue(value.getValue());
            if (aDataCalibracao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataCalibracao(String value) {
        if (value == null) {
            nullifyDataCalibracao();
        } else {
            aDataCalibracao.setValue(value);
            if (aDataCalibracao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataCalibracao(java.sql.Date value) {
        aDataCalibracao.setValue(value);
        if (aDataCalibracao.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataCalibracao(Object value) {
        aDataCalibracao.setValue(value);
        if (aDataCalibracao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataCalibracao() {
        if (!aDataCalibracao.isNull()) {
            aDataCalibracao.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataCalibracao() {
        return aDataCalibracao;
    }
    
    public DomDate oldDataCalibracao() {
        return oDataCalibracao;
    }
    
    public java.sql.Date valueOfDataCalibracao() {
        return aDataCalibracao.getValue();
    }
    
    public boolean isDataCalibracaoModified() {
        return aDataCalibracao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_VALIDADE">
    
    public EntCertificadoCalibracao dataValidade(java.sql.Date value) {
        setDataValidade(value);
        return this;
    }
    
    public void setDataValidade(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataValidade();
        } else {
            aDataValidade.setValue(value.getValue());
            if (aDataValidade.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataValidade(String value) {
        if (value == null) {
            nullifyDataValidade();
        } else {
            aDataValidade.setValue(value);
            if (aDataValidade.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataValidade(java.sql.Date value) {
        aDataValidade.setValue(value);
        if (aDataValidade.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataValidade(Object value) {
        aDataValidade.setValue(value);
        if (aDataValidade.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataValidade() {
        if (!aDataValidade.isNull()) {
            aDataValidade.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataValidade() {
        return aDataValidade;
    }
    
    public DomDate oldDataValidade() {
        return oDataValidade;
    }
    
    public java.sql.Date valueOfDataValidade() {
        return aDataValidade.getValue();
    }
    
    public boolean isDataValidadeModified() {
        return aDataValidade.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CERTIFICADO">
    
    public EntCertificadoCalibracao certificado(String value) {
        setCertificado(value);
        return this;
    }
    
    public void setCertificado(DomText value) {
        if (value == null || value.isNull()) {
            nullifyCertificado();
        } else {
            aCertificado.setValue(value.getValue());
            if (aCertificado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificado(String value) {
        if (value == null) {
            nullifyCertificado();
        } else {
            aCertificado.setValue(value);
            if (aCertificado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificado(Object value) {
        aCertificado.setValue(value);
        if (aCertificado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCertificado() {
        if (!aCertificado.isNull()) {
            aCertificado.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getCertificado() {
        return aCertificado;
    }
    
    public DomText oldCertificado() {
        return oCertificado;
    }
    
    public String valueOfCertificado() {
        return aCertificado.getValue();
    }
    
    public boolean isCertificadoModified() {
        return aCertificado.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE
        {
            EntInstrumentoEnsaio external = new EntInstrumentoEnsaio(ctx);
            external.findByCertificadoCalibracaoCorrente(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Instrumentos para ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade ZTEST.CALIBRACAO_INSTRUMENTO.FK_CALINS_CERTIFICADO_CALIBRACAO
        {
            EntCalibracaoInstrumento calibracaoInstrumento = new EntCalibracaoInstrumento(ctx);
            calibracaoInstrumento.del("select id from CALIBRACAO_INSTRUMENTO where CERTIFICADO_CALIBRACAO_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Instrumentos para ensaios fazendo referencia para este registro! (FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE)");
                return e;
            } else {
                e = new AdsException("ZTEST.CERTIFICADO_CALIBRACAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("FK_CERCAL_INSTRUMENTO_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.CERTIFICADO_CALIBRACAO.FK_CERCAL_INSTRUMENTO_ENSAIO", 
                        Severity.ERROR,
                        "Registro não cadastrado para INSTRUMENTO_ENSAIO! (FK_CERCAL_INSTRUMENTO_ENSAIO)");
                return e;
            } else if (msg.indexOf("PK_CERCAL") >= 0) {
                e = new AdsException("ZTEST.CERTIFICADO_CALIBRACAO.PK_CERCAL", 
                        Severity.ERROR,
                        "ID duplicado! (PK_CERCAL)");
                return e;
            } else {
                e = new AdsException("ZTEST.CERTIFICADO_CALIBRACAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aInstrumentoEnsaioId);
            allAttributes.add(aDataCalibracao);
            allAttributes.add(aDataValidade);
            allAttributes.add(aCertificado);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return "";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    private EntInstrumentoEnsaio eInstrumentoEnsaio;
    
    public EntInstrumentoEnsaio findInstrumentoEnsaio() throws AdsException {
        if (getInstrumentoEnsaioId().isNull()) {
            return null;
        }
        if (eInstrumentoEnsaio == null || !valueOfInstrumentoEnsaioId().equals(eInstrumentoEnsaio.valueOfId())) {
            eInstrumentoEnsaio = new EntInstrumentoEnsaio(ctx);
            eInstrumentoEnsaio.find(valueOfInstrumentoEnsaioId());
        }
        return eInstrumentoEnsaio;
    }
    
    /**
     * Ativa o join desta entidade com INSTRUMENTO_ENSAIO
     * através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntInstrumentoEnsaio joinInstrumentoEnsaio() {
        return joinInstrumentoEnsaio(null);
    }
    public EntInstrumentoEnsaio joinInstrumentoEnsaio(String alias) {
        EntInstrumentoEnsaio entity = new EntInstrumentoEnsaio(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getInstrumentoEnsaioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByInstrumentoEnsaio(long id, String sqlAppend) throws AdsException {
        find("select ID from CERTIFICADO_CALIBRACAO where INSTRUMENTO_ENSAIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByInstrumentoEnsaio(long id) throws AdsException {
        findByInstrumentoEnsaio(id,"");
    }
    
    public void findByInstrumentoEnsaio(Entity entidade) throws AdsException {
        findByInstrumentoEnsaio(entidade.valueOfId(),"");
    }
    
    public void findByInstrumentoEnsaio(Entity entidade, String sqlAppend) throws AdsException {
        findByInstrumentoEnsaio(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eInstrumentoEnsaio = null;
    }
    /**
     * Retorna os registros de INSTRUMENTO_ENSAIO que referenciam este registro através do atributo CERTIFICADO_CALIBRACAO_CORRENTE_ID
     */
    public EntInstrumentoEnsaio findAllInstrumentoEnsaioCertificadoCalibracaoCorrente() throws AdsException {
        return findAllInstrumentoEnsaioCertificadoCalibracaoCorrente("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUMENTO_ENSAIO que referenciam este registro através do atributo CERTIFICADO_CALIBRACAO_CORRENTE_ID
     */
    public EntInstrumentoEnsaio findAllInstrumentoEnsaioCertificadoCalibracaoCorrente(String sqlAppend) throws AdsException {
        EntInstrumentoEnsaio out = new EntInstrumentoEnsaio(ctx);
        out.find("select ID from INSTRUMENTO_ENSAIO where CERTIFICADO_CALIBRACAO_CORRENTE_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de CALIBRACAO_INSTRUMENTO que referenciam este registro através do atributo CERTIFICADO_CALIBRACAO_ID
     */
    public EntCalibracaoInstrumento findAllCalibracaoInstrumentoCertificadoCalibracao() throws AdsException {
        return findAllCalibracaoInstrumentoCertificadoCalibracao("order by ID");
    }
    
    /**
     * Retorna os registros de CALIBRACAO_INSTRUMENTO que referenciam este registro através do atributo CERTIFICADO_CALIBRACAO_ID
     */
    public EntCalibracaoInstrumento findAllCalibracaoInstrumentoCertificadoCalibracao(String sqlAppend) throws AdsException {
        EntCalibracaoInstrumento out = new EntCalibracaoInstrumento(ctx);
        out.find("select ID from CALIBRACAO_INSTRUMENTO where CERTIFICADO_CALIBRACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oCertificado.setValue(aCertificado);
        oDataValidade.setValue(aDataValidade);
        oDataCalibracao.setValue(aDataCalibracao);
        oInstrumentoEnsaioId.setValue(aInstrumentoEnsaioId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntCertificadoCalibracao.class);
            rule.setName("PK_CERCAL");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntCertificadoCalibracao.class);
            rule.setAssociatedEntity(EntInstrumentoEnsaio.class);
            rule.setName("FK_CERCAL_INSTRUMENTO_ENSAIO");
            rule.addAttribute(new DomId("INSTRUMENTO_ENSAIO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
